{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.10.13","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"gpu","dataSources":[{"sourceId":8640523,"sourceType":"datasetVersion","datasetId":5174680}],"dockerImageVersionId":30733,"isInternetEnabled":false,"language":"python","sourceType":"notebook","isGpuEnabled":true}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"import os\nimport time\nimport torch\nimport torch.backends.cudnn as cudnn\nimport torch.nn as nn\nfrom torch.utils.data import DataLoader\nimport torch.nn.functional as F\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport pickle\nimport torchvision.transforms as transforms\nimport torchvision.datasets as datasets\n\n# 定义学习率、动量、权重衰减等超参数\nlr = 0.01\nmomentum = 0.9\nweight_decay = 1e-4\nstart_epoch = 0\nepochs = 100\n\n# 根据是否有CUDA设备，选择合适的设备\ndevice = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n\n# z-pool池化层，用于结合最大值和平均值\nclass ZPool(nn.Module):\n    def forward(self, x):\n        return torch.cat((torch.max(x, 1)[0].unsqueeze(1), torch.mean(x, 1).unsqueeze(1)), dim=1)\n\n\n# 注意力模块\nclass SpatialGate(nn.Module):\n    def __init__(self):\n        super(SpatialGate, self).__init__()\n        # 先Z-Pool池化\n        self.z_pool = ZPool()\n        # 再卷积 k*k的卷积核卷积->归一化处理\n        self.conv = nn.Sequential(\n            nn.Conv2d(in_channels=2, out_channels=1, kernel_size=7, stride=1, padding=3),\n            nn.BatchNorm2d(1)\n        )\n        # 通过sigmoid来生成的注意力权值\n        self.sigmoid = nn.Sigmoid()\n\n    def forward(self, x):\n        z_pool_out = self.z_pool(x)\n        out = self.conv(z_pool_out)\n        return x * self.sigmoid(out)\n\n# 用于实现三元组注意力机制\nclass TripletAttention(nn.Module):\n    def __init__(self, spatial=True):\n        super(TripletAttention, self).__init__()\n        self.spatial = spatial\n\n        # 对三个分支进行初始化\n        # 通道C和空间W维度交互\n        self.cw = SpatialGate()\n        # 通道C和空间H维度交互\n        self.ch = SpatialGate()\n        # 空间H和空间W进行注意力计算\n        if self.spatial:\n            self.hw = SpatialGate()\n\n    def forward(self, x):\n        # 0 2 1 3    b w c h\n        x_perm1 = x.permute(0, 2, 1, 3).contiguous()\n        x_out1 = self.ch(x_perm1)\n        # 0 2 1 3    b c w h\n        x_out1 = x_out1.permute(0, 2, 1, 3).contiguous()\n\n        # 0 3 2 1    b h w c\n        x_perm2 = x.permute(0, 3, 2, 1).contiguous()\n        x_out2 = self.cw(x_perm2)\n        # 0 3 2 1    b c w h\n        x_out2 = x_out2.permute(0, 3, 2, 1).contiguous()\n\n        if self.spatial:\n            x_out3 = self.hw(x)\n            return (1 / 3) * (x_out1 + x_out2 + x_out3)\n        else:\n            return (1 / 2) * (x_out1 + x_out2)\n\n\n# SE模块\nclass SEModule(nn.Module):\n    def __init__(self, channels, reduction=16):\n        super(SEModule, self).__init__()\n        self.avg_pool = nn.AdaptiveAvgPool2d(1)\n        self.fc1 = nn.Conv2d(channels, channels // reduction, kernel_size=1, padding=0)\n        self.relu = nn.ReLU(inplace=True)\n        self.fc2 = nn.Conv2d(channels // reduction, channels, kernel_size=1, padding=0)\n        self.sigmoid = nn.Sigmoid()\n\n    def forward(self, input):\n        x = self.avg_pool(input)\n        x = self.fc1(x)\n        x = self.relu(x)\n        x = self.fc2(x)\n        x = self.sigmoid(x)\n        return input * x\n\n\n# 残差层\nclass Bottleneck(nn.Module):\n    # 输出通道数为输入通道数的4倍\n    expansion = 4\n\n    # 后续需要为其添加新参数\n    def __init__(self, inplanes, planes, stride=1, downsample=None, scales=4, groups=1, is_first_block=0,\n                 activation='gelu'):\n        super(Bottleneck, self).__init__()\n\n        self.downsample = downsample\n        self.scales = scales\n        self.groups = groups\n        self.stride = stride\n        self.is_first_block = is_first_block\n\n        # 激活函数\n        if activation == 'relu':\n            self.activation = nn.ReLU(inplace=True)\n        elif activation == 'celu':\n            self.activation = nn.CELU(inplace=True)\n        elif activation == 'gelu':\n            self.activation = nn.GELU()\n        elif activation == 'elu':\n            self.activation = nn.ELU(inplace=True)\n        elif activation == 'leaky-relu':\n            self.activation = nn.LeakyReLU(inplace=True)\n        else:\n            raise NotImplementedError(f\"Activation not implemented!\")\n\n        outplanes = groups * planes\n        # 第一个卷积层：卷积核尺寸： 1×1 ，填充值为 0， 步长为 1\n        self.conv1 = nn.Conv2d(in_channels=inplanes, out_channels=outplanes, kernel_size=1, stride=1, bias=False)\n        self.bn1 = nn.BatchNorm2d(outplanes)\n\n        # 第二个卷积结构：卷积核尺寸： 3×3 ，填充值为 1， 步长为 1\n        self.conv2 = nn.ModuleList([nn.Conv2d(outplanes // scales, outplanes // scales,\n                                              kernel_size=3, stride=stride, padding=1, groups=groups, bias=False) for _\n                                    in\n                                    range(scales - 1)])\n        self.bn2 = nn.ModuleList([nn.BatchNorm2d(outplanes // scales) for _ in range(scales - 1)])\n\n        # 第三个卷积层：卷积核尺寸： 1×1 ，填充值为 0， 步长为 1\n        self.conv3 = nn.Conv2d(outplanes, planes * self.expansion, kernel_size=1, stride=1, bias=False)\n        self.bn3 = nn.BatchNorm2d(planes * self.expansion)\n        \n        # 处理第一个块\n        if is_first_block == 1:\n            self.pool = nn.AvgPool2d(kernel_size=3, stride=stride, padding=1)\n\n        # SE模块\n        self.se = SEModule(planes * self.expansion)\n        self.semodule = SEModule(outplanes // scales)\n        # TA模块\n        self.ta = TripletAttention()\n\n    def forward(self, x):\n        identity = x  # 将原始输入暂存为shortcut的输出\n        # 对下采样进行处理\n        # 如果Indentity block就是直连；如果Conv2 Block就需要对残差边就行卷积，改变通道数和size\n        if self.downsample is not None:\n            identity = self.downsample(identity)\n\n        # 1*1卷积层\n        out = self.conv1(x)\n        out = self.bn1(out)\n        out = self.activation(out)\n        \n        # 3*3卷积结构\n        x_scales = torch.chunk(out, self.scales, 1)\n        for i in range(self.scales - 1):\n            if i == 0 or self.is_first_block == 1:\n                y_scale = x_scales[i]\n            else:\n                y_scale = y_scale + x_scales[i]\n            y_scale = self.conv2[i](y_scale)\n            y_scale = self.activation(self.bn2[i](y_scale))\n            y_scale = self.semodule(y_scale)\n            y_scale = self.ta(y_scale)\n            if i == 0:\n                out = y_scale\n            else:\n                out = torch.cat((out, y_scale), 1)\n        if self.scales != 1 and self.is_first_block == 0:\n            out = torch.cat((out, x_scales[self.scales - 1]), 1)\n        elif self.scales != 1 and self.is_first_block == 1:\n            out = torch.cat((out, self.pool(x_scales[self.scales - 1])), 1)\n\n        # 1*1卷积层\n        out = self.conv3(out)\n        out = self.bn3(out)\n\n        # 是否加入SE模块--该结构利用系数scale来使网络自适应的减弱或增强该通道的特征，与注意力机制有异曲同工之妙。\n        out = self.se(out)\n        \n        # 添加triplet_attention\n        out = self.ta(out)\n\n        # 残差连接 out=F(X)+X\n        out += identity\n        \n        self.activation(out)\n\n        return out\n\n\nclass Res2Net(nn.Module):\n    def __init__(self, block, layers, num_classes=1000, scales=4, groups=1):\n        super(Res2Net, self).__init__()\n        \n        # 通道数初始化\n        self.inplanes = 64\n\n        # 起始：3*3的卷积层，3*3的最大池化层\n        self.conv1 = nn.Sequential(\n             nn.Conv2d(3, self.inplanes, kernel_size=3, stride=1, padding=1, bias=False),\n             nn.BatchNorm2d(self.inplanes),\n             nn.ReLU(inplace=True),\n             nn.Conv2d(self.inplanes, self.inplanes, kernel_size=3, stride=1, padding=1, bias=False),\n             nn.BatchNorm2d(self.inplanes),\n             nn.ReLU(inplace=True),\n             nn.Conv2d(self.inplanes, self.inplanes, kernel_size=3, stride=1, padding=1, bias=False),\n             nn.BatchNorm2d(self.inplanes),\n             nn.ReLU(inplace=True)\n             )\n\n        self.bn1 = nn.BatchNorm2d(self.inplanes)\n        self.relu = nn.ReLU(inplace=True)\n        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=1, padding=1)\n\n        # 残差结构\n        self.layer1 = self._make_layer(block, 64, layers[0], stride=1, scales=scales, groups=groups)\n        self.layer2 = self._make_layer(block, 128, layers[1], stride=2, scales=scales, groups=groups)\n        self.layer3 = self._make_layer(block, 256, layers[2], stride=2, scales=scales, groups=groups)\n        self.layer4 = self._make_layer(block, 512, layers[3], stride=2, scales=scales, groups=groups)\n\n        # 平均池化+全连接层\n        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))\n        self.fc = nn.Linear(512 * block.expansion, num_classes)\n\n        # 权重初始化\n        for m in self.modules():\n            if isinstance(m, nn.Conv2d):\n                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')\n            elif isinstance(m, nn.BatchNorm2d):\n                nn.init.constant_(m.weight, 1)\n                nn.init.constant_(m.bias, 0)\n\n    def _make_layer(self, block, planes, layer, stride=1, scales=4, groups=1, se=True):\n        # 积步长不为1或深度扩张有变化，导致F(X)与X的shape不同的残差块，就要对X定义下采样函数，使之shape相同\n        downsample = None\n        if stride != 1 or self.inplanes != planes * block.expansion:\n            downsample = nn.Sequential(\n                nn.Conv2d(self.inplanes, planes * block.expansion, kernel_size=1, stride=stride, bias=False),\n                nn.BatchNorm2d(planes * block.expansion),\n            )\n\n        layers = []\n        # 第一个残差块需要下采样\n        layers.append(block(self.inplanes, planes, stride=stride, downsample=downsample,\n                            scales=scales, groups=groups, is_first_block=1))\n        self.inplanes = planes * block.expansion\n\n        # 通过循环堆叠其余残差块\n        for i in range(1, layer):\n            layers.append(block(self.inplanes, planes, scales=scales, groups=groups))\n\n        return nn.Sequential(*layers)\n\n    def forward(self, x):\n        x = self.conv1(x)\n        x = self.bn1(x)\n        x = self.relu(x)\n        x = self.maxpool(x)\n\n        x = self.layer1(x)\n        x = self.layer2(x)\n        x = self.layer3(x)\n        x = self.layer4(x)\n\n        x = self.avgpool(x)\n        x = torch.flatten(x, 1)\n        x = self.fc(x)\n\n        return x\n\n\ndef res2net50(num_classes=100, scales=4, groups=1):\n    return Res2Net(Bottleneck, [3, 4, 6, 3], num_classes, scales, groups)\n\n\ndef res2net101(num_classes=100, scales=4, groups=1):\n    return Res2Net(Bottleneck, [3, 4, 23, 3], num_classes, scales, groups)\n\n\nif __name__ == \"__main__\":\n    transform_train = transforms.Compose([\n        transforms.RandomCrop(32, padding=4),\n        transforms.RandomHorizontalFlip(),\n        transforms.RandomVerticalFlip(),  # 随机垂直翻转\n        transforms.RandomRotation(10),  # 随机旋转\n        transforms.ToTensor(),\n        transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),\n    ])\n    transform_test = transforms.Compose([\n        transforms.ToTensor(),\n        transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),\n    ])\n    train_set = datasets.CIFAR100('/kaggle/input/mydata', train=True,\n                                  download=False, transform=transform_train)\n    test_set = datasets.CIFAR100('/kaggle/input/mydata', train=False,\n                                 download=False, transform=transform_test)\n    train_loader = torch.utils.data.DataLoader(train_set, batch_size=128,\n                                               shuffle=True, num_workers=4)\n    val_loader = torch.utils.data.DataLoader(test_set, batch_size=128,\n                                             shuffle=False, num_workers=4)\n    global model\n    model = res2net101()\n    model.to(device)\n    #损失函数\n    loss_fn=nn.CrossEntropyLoss() \n    loss_fn.to(device)\n    # define loss function (criterion) and optimizer\n    criterion = nn.CrossEntropyLoss().to(device)\n    optimizer = torch.optim.SGD(\n        model.parameters(),\n        lr,\n        momentum=momentum,\n        weight_decay=weight_decay,\n    )\n    cudnn.benchmark = True\n    train_acc_list = []\n    train_loss_list = []\n    test_acc_list = []\n    test_loss_list=[]\n    for epoch in range(start_epoch, epochs):\n        print(\"-----第{}轮训练开始------\".format(epoch + 1))\n        train_loss=0.0\n        test_loss=0.0\n        train_sum,train_cor,test_sum,test_cor=0,0,0,0\n \n        #训练步骤开始\n        model.train()\n        for batch_idx,(data,target) in enumerate(train_loader):\n            data,target=data.to(device),target.to(device)\n \n            optimizer.zero_grad()  # 要将梯度清零，因为如果梯度不清零，pytorch中会将上次计算的梯度和本次计算的梯度累加\n            output = model(data)\n            loss = loss_fn(output, target)\n            loss.backward()\n            optimizer.step()  # 更新所有的参数\n \n            # 计算每轮训练集的Loss\n            train_loss += loss.item()\n \n            _, predicted = torch.max(output.data, 1)  # 选择最大的（概率）值所在的列数就是他所对应的类别数，\n            train_cor += (predicted == target).sum().item()  # 正确分类个数\n            train_sum += target.size(0)  # train_sum+=predicted.shape[0]\n \n        #测试步骤开始\n        model.eval()\n        with torch.no_grad():\n            for batch_idx1,(data,target) in enumerate(val_loader):\n                data, target = data.to(device), target.to(device)\n \n                output = model(data)\n                loss = loss_fn(output, target)\n                test_loss+=loss.item()\n                _, predicted = torch.max(output.data, 1)\n                test_cor += (predicted == target).sum().item()\n                test_sum += target.size(0)\n     \n        print(\"Train loss:{}   Train accuracy:{}%   Test loss:{}   Test accuracy:{}%\".format(train_loss/batch_idx,100*train_cor/train_sum,\n                                                                                       test_loss/batch_idx1,100*test_cor/test_sum))\n        train_loss_list.append(train_loss / batch_idx)\n        train_acc_list.append(100 * train_cor / train_sum)\n        test_acc_list.append(100 * test_cor/ test_sum)\n        test_loss_list.append(test_loss / batch_idx1)\n \n        #保存网络\n        torch.save(model,\"/kaggle/working/CIFAR100_epoch{}.pth\".format(epoch))\n","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","execution":{"iopub.status.busy":"2024-06-10T04:43:58.763749Z","iopub.execute_input":"2024-06-10T04:43:58.764491Z","iopub.status.idle":"2024-06-10T13:59:18.784693Z","shell.execute_reply.started":"2024-06-10T04:43:58.764449Z","shell.execute_reply":"2024-06-10T13:59:18.783430Z"},"trusted":true},"execution_count":1,"outputs":[{"name":"stdout","text":"-----第1轮训练开始------\nTrain loss:3.745548171263475   Train accuracy:13.222%   Test loss:3.430050388360635   Test accuracy:18.93%\n-----第2轮训练开始------\nTrain loss:3.129056132145417   Train accuracy:23.306%   Test loss:2.9326676038595347   Test accuracy:27.53%\n-----第3轮训练开始------\nTrain loss:2.7756434391706417   Train accuracy:29.794%   Test loss:2.6519516828732614   Test accuracy:32.62%\n-----第4轮训练开始------\nTrain loss:2.51392652682769   Train accuracy:35.064%   Test loss:2.4521924685209227   Test accuracy:36.41%\n-----第5轮训练开始------\nTrain loss:2.315493554335374   Train accuracy:38.972%   Test loss:2.2732673593056507   Test accuracy:39.47%\n-----第6轮训练开始------\nTrain loss:2.1442022115756303   Train accuracy:42.668%   Test loss:2.1663126930212364   Test accuracy:42.26%\n-----第7轮训练开始------\nTrain loss:2.0054354306979056   Train accuracy:45.702%   Test loss:2.079199567819253   Test accuracy:45.09%\n-----第8轮训练开始------\nTrain loss:1.8863586868995275   Train accuracy:48.268%   Test loss:1.9906182334973261   Test accuracy:47.13%\n-----第9轮训练开始------\nTrain loss:1.7702888418466618   Train accuracy:51.056%   Test loss:1.9321294977114751   Test accuracy:48.18%\n-----第10轮训练开始------\nTrain loss:1.6705254383576222   Train accuracy:53.134%   Test loss:1.933499460036938   Test accuracy:48.61%\n-----第11轮训练开始------\nTrain loss:1.5865155742718624   Train accuracy:55.264%   Test loss:1.8115514837778532   Test accuracy:51.38%\n-----第12轮训练开始------\nTrain loss:1.494241609940162   Train accuracy:57.568%   Test loss:1.7774792069043868   Test accuracy:52.47%\n-----第13轮训练开始------\nTrain loss:1.4071936665437161   Train accuracy:59.612%   Test loss:1.7836288458261735   Test accuracy:51.75%\n-----第14轮训练开始------\nTrain loss:1.33203616020007   Train accuracy:61.47%   Test loss:1.7481762843254285   Test accuracy:53.27%\n-----第15轮训练开始------\nTrain loss:1.2523336994342316   Train accuracy:63.522%   Test loss:1.6972805322744908   Test accuracy:55.25%\n-----第16轮训练开始------\nTrain loss:1.1802634696165721   Train accuracy:65.238%   Test loss:1.7653842384998615   Test accuracy:53.74%\n-----第17轮训练开始------\nTrain loss:1.1094481176290756   Train accuracy:67.172%   Test loss:1.6866052471674406   Test accuracy:54.82%\n-----第18轮训练开始------\nTrain loss:1.0441383375571325   Train accuracy:68.864%   Test loss:1.7249242449418092   Test accuracy:54.4%\n-----第19轮训练开始------\nTrain loss:0.9742488229886079   Train accuracy:70.724%   Test loss:1.7140462887592804   Test accuracy:55.36%\n-----第20轮训练开始------\nTrain loss:0.9085807684140328   Train accuracy:72.47%   Test loss:1.715089860634926   Test accuracy:55.55%\n-----第21轮训练开始------\nTrain loss:0.8390905297719515   Train accuracy:74.27%   Test loss:1.7704870838385363   Test accuracy:55.13%\n-----第22轮训练开始------\nTrain loss:0.7911274213057298   Train accuracy:75.756%   Test loss:1.737493681601989   Test accuracy:56.35%\n-----第23轮训练开始------\nTrain loss:0.7220618432913071   Train accuracy:77.518%   Test loss:1.792991885772118   Test accuracy:55.32%\n-----第24轮训练开始------\nTrain loss:0.6705119002323884   Train accuracy:79.034%   Test loss:1.7849104389166222   Test accuracy:56.03%\n-----第25轮训练开始------\nTrain loss:0.6064768659762847   Train accuracy:80.958%   Test loss:1.8581018829957032   Test accuracy:56.4%\n-----第26轮训练开始------\nTrain loss:0.560277935786125   Train accuracy:82.266%   Test loss:1.8513084665322914   Test accuracy:55.39%\n-----第27轮训练开始------\nTrain loss:0.5051905770332386   Train accuracy:83.746%   Test loss:1.9260874482301564   Test accuracy:55.4%\n-----第28轮训练开始------\nTrain loss:0.46250488055058014   Train accuracy:85.076%   Test loss:1.8983642244950318   Test accuracy:56.74%\n-----第29轮训练开始------\nTrain loss:0.43363580371324834   Train accuracy:85.926%   Test loss:1.9660938015350928   Test accuracy:56.24%\n-----第30轮训练开始------\nTrain loss:0.392166912708527   Train accuracy:87.362%   Test loss:1.9890930713751378   Test accuracy:56.34%\n-----第31轮训练开始------\nTrain loss:0.34699104237250794   Train accuracy:88.806%   Test loss:2.0098254466668153   Test accuracy:56.57%\n-----第32轮训练开始------\nTrain loss:0.3263631482154895   Train accuracy:89.444%   Test loss:2.062406435990945   Test accuracy:56.57%\n-----第33轮训练开始------\nTrain loss:0.29739191589447167   Train accuracy:90.126%   Test loss:1.9972581236790388   Test accuracy:57.21%\n-----第34轮训练开始------\nTrain loss:0.27185288751736664   Train accuracy:91.19%   Test loss:2.008071870375902   Test accuracy:58.0%\n-----第35轮训练开始------\nTrain loss:0.2540167393401647   Train accuracy:91.508%   Test loss:2.143556759907649   Test accuracy:57.15%\n-----第36轮训练开始------\nTrain loss:0.23588994773916708   Train accuracy:92.346%   Test loss:2.1347189224683323   Test accuracy:56.98%\n-----第37轮训练开始------\nTrain loss:0.21827992365146295   Train accuracy:92.93%   Test loss:2.1197615143580313   Test accuracy:57.69%\n-----第38轮训练开始------\nTrain loss:0.19892678388800378   Train accuracy:93.424%   Test loss:2.130688149195451   Test accuracy:58.12%\n-----第39轮训练开始------\nTrain loss:0.19001668112782333   Train accuracy:93.846%   Test loss:2.13547643331381   Test accuracy:57.99%\n-----第40轮训练开始------\nTrain loss:0.17612278615243923   Train accuracy:94.238%   Test loss:2.226265551188053   Test accuracy:57.11%\n-----第41轮训练开始------\nTrain loss:0.16801340414736515   Train accuracy:94.572%   Test loss:2.202380258303422   Test accuracy:57.76%\n-----第42轮训练开始------\nTrain loss:0.14916162324639468   Train accuracy:95.136%   Test loss:2.1504426338733773   Test accuracy:59.07%\n-----第43轮训练开始------\nTrain loss:0.12802152750201715   Train accuracy:95.968%   Test loss:2.1513048379849167   Test accuracy:58.72%\n-----第44轮训练开始------\nTrain loss:0.13201990404572242   Train accuracy:95.738%   Test loss:2.2188644974659653   Test accuracy:58.58%\n-----第45轮训练开始------\nTrain loss:0.13449600741076165   Train accuracy:95.674%   Test loss:2.18877695615475   Test accuracy:58.59%\n-----第46轮训练开始------\nTrain loss:0.12075723444040005   Train accuracy:96.19%   Test loss:2.2580630412468543   Test accuracy:57.8%\n-----第47轮训练开始------\nTrain loss:0.11459563190165238   Train accuracy:96.366%   Test loss:2.2191106294974303   Test accuracy:58.5%\n-----第48轮训练开始------\nTrain loss:0.10675212675944352   Train accuracy:96.606%   Test loss:2.298585240657513   Test accuracy:58.02%\n-----第49轮训练开始------\nTrain loss:0.10236399696710018   Train accuracy:96.736%   Test loss:2.285819868246714   Test accuracy:58.38%\n-----第50轮训练开始------\nTrain loss:0.10559230570036632   Train accuracy:96.652%   Test loss:2.2348178197176027   Test accuracy:59.4%\n-----第51轮训练开始------\nTrain loss:0.09384613879120503   Train accuracy:97.158%   Test loss:2.306256120021527   Test accuracy:58.75%\n-----第52轮训练开始------\nTrain loss:0.09057490893233663   Train accuracy:97.152%   Test loss:2.26311409779084   Test accuracy:59.21%\n-----第53轮训练开始------\nTrain loss:0.09332936001607241   Train accuracy:96.89%   Test loss:2.270283124385736   Test accuracy:58.56%\n-----第54轮训练开始------\nTrain loss:0.08711686920947753   Train accuracy:97.256%   Test loss:2.282642207084558   Test accuracy:58.22%\n-----第55轮训练开始------\nTrain loss:0.08452260685272706   Train accuracy:97.336%   Test loss:2.250670926693158   Test accuracy:58.45%\n-----第56轮训练开始------\nTrain loss:0.07978955209255219   Train accuracy:97.55%   Test loss:2.2820007640581865   Test accuracy:58.69%\n-----第57轮训练开始------\nTrain loss:0.07361486302449917   Train accuracy:97.634%   Test loss:2.258692735280746   Test accuracy:59.27%\n-----第58轮训练开始------\nTrain loss:0.06941709617773692   Train accuracy:97.816%   Test loss:2.2711732601508117   Test accuracy:58.92%\n-----第59轮训练开始------\nTrain loss:0.06857103057539998   Train accuracy:97.876%   Test loss:2.247633599317991   Test accuracy:59.39%\n-----第60轮训练开始------\nTrain loss:0.07320054213110454   Train accuracy:97.69%   Test loss:2.2771200858629665   Test accuracy:58.71%\n-----第61轮训练开始------\nTrain loss:0.0622124683088026   Train accuracy:98.166%   Test loss:2.2573397954305015   Test accuracy:59.49%\n-----第62轮训练开始------\nTrain loss:0.059359485839899535   Train accuracy:98.154%   Test loss:2.2664167361381726   Test accuracy:59.24%\n-----第63轮训练开始------\n","output_type":"stream"},{"traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)","Cell \u001b[0;32mIn[1], line 352\u001b[0m\n\u001b[1;32m    350\u001b[0m output \u001b[38;5;241m=\u001b[39m model(data)\n\u001b[1;32m    351\u001b[0m loss \u001b[38;5;241m=\u001b[39m loss_fn(output, target)\n\u001b[0;32m--> 352\u001b[0m \u001b[43mloss\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbackward\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    353\u001b[0m optimizer\u001b[38;5;241m.\u001b[39mstep()  \u001b[38;5;66;03m# 更新所有的参数\u001b[39;00m\n\u001b[1;32m    355\u001b[0m \u001b[38;5;66;03m# 计算每轮训练集的Loss\u001b[39;00m\n","File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/torch/_tensor.py:492\u001b[0m, in \u001b[0;36mTensor.backward\u001b[0;34m(self, gradient, retain_graph, create_graph, inputs)\u001b[0m\n\u001b[1;32m    482\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m has_torch_function_unary(\u001b[38;5;28mself\u001b[39m):\n\u001b[1;32m    483\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m handle_torch_function(\n\u001b[1;32m    484\u001b[0m         Tensor\u001b[38;5;241m.\u001b[39mbackward,\n\u001b[1;32m    485\u001b[0m         (\u001b[38;5;28mself\u001b[39m,),\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    490\u001b[0m         inputs\u001b[38;5;241m=\u001b[39minputs,\n\u001b[1;32m    491\u001b[0m     )\n\u001b[0;32m--> 492\u001b[0m \u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mautograd\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbackward\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    493\u001b[0m \u001b[43m    \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgradient\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mretain_graph\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcreate_graph\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minputs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minputs\u001b[49m\n\u001b[1;32m    494\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n","File \u001b[0;32m/opt/conda/lib/python3.10/site-packages/torch/autograd/__init__.py:251\u001b[0m, in \u001b[0;36mbackward\u001b[0;34m(tensors, grad_tensors, retain_graph, create_graph, grad_variables, inputs)\u001b[0m\n\u001b[1;32m    246\u001b[0m     retain_graph \u001b[38;5;241m=\u001b[39m create_graph\n\u001b[1;32m    248\u001b[0m \u001b[38;5;66;03m# The reason we repeat the same comment below is that\u001b[39;00m\n\u001b[1;32m    249\u001b[0m \u001b[38;5;66;03m# some Python versions print out the first line of a multi-line function\u001b[39;00m\n\u001b[1;32m    250\u001b[0m \u001b[38;5;66;03m# calls in the traceback and some print out the last line\u001b[39;00m\n\u001b[0;32m--> 251\u001b[0m \u001b[43mVariable\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_execution_engine\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrun_backward\u001b[49m\u001b[43m(\u001b[49m\u001b[43m  \u001b[49m\u001b[38;5;66;43;03m# Calls into the C++ engine to run the backward pass\u001b[39;49;00m\n\u001b[1;32m    252\u001b[0m \u001b[43m    \u001b[49m\u001b[43mtensors\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    253\u001b[0m \u001b[43m    \u001b[49m\u001b[43mgrad_tensors_\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    254\u001b[0m \u001b[43m    \u001b[49m\u001b[43mretain_graph\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    255\u001b[0m \u001b[43m    \u001b[49m\u001b[43mcreate_graph\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    256\u001b[0m \u001b[43m    \u001b[49m\u001b[43minputs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    257\u001b[0m \u001b[43m    \u001b[49m\u001b[43mallow_unreachable\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m    258\u001b[0m \u001b[43m    \u001b[49m\u001b[43maccumulate_grad\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mTrue\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m    259\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n","\u001b[0;31mKeyboardInterrupt\u001b[0m: "],"ename":"KeyboardInterrupt","evalue":"","output_type":"error"}]},{"cell_type":"code","source":"# 加载模型\nmodel = torch.load(\"/kaggle/working/CIFAR100_epoch60.pth\")\nmodel = model.to(device)\n\n# 测试步骤开始\nmodel.eval()\ncorrect = 0\ntotal = 0\nwith torch.no_grad():\n    for data in val_loader:\n        images, labels = data\n        images, labels = images.to(device), labels.to(device)\n        outputs = model(images)\n        _, predicted = torch.max(outputs.data, 1)\n        total += labels.size(0)\n        correct += (predicted == labels).sum().item()\n\nprint('Accuracy of the network on the test images: %d %%' % (\n    100 * correct / total))","metadata":{"execution":{"iopub.status.busy":"2024-06-10T13:59:32.778379Z","iopub.execute_input":"2024-06-10T13:59:32.779227Z","iopub.status.idle":"2024-06-10T13:59:58.879427Z","shell.execute_reply.started":"2024-06-10T13:59:32.779192Z","shell.execute_reply":"2024-06-10T13:59:58.877695Z"},"trusted":true},"execution_count":3,"outputs":[{"name":"stdout","text":"Accuracy of the network on the test images: 59 %\n","output_type":"stream"}]},{"cell_type":"code","source":"import matplotlib.pyplot as plt\n\n# 创建一个新的图像\nplt.figure()\n\n# 绘制训练精度\nplt.plot(range(60), train_acc_list[:-2], label='Train Accuracy')\n\n# 绘制测试精度\nplt.plot(range(60), test_acc_list[:-2], label='Test Accuracy')\n\n# 添加图例\nplt.legend()\n\n# 添加标题和标签\nplt.title('Train and Test Accuracy')\nplt.xlabel('Epoch')\nplt.ylabel('Accuracy')\n\n# 显示图像\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2024-06-10T14:03:12.962981Z","iopub.execute_input":"2024-06-10T14:03:12.963341Z","iopub.status.idle":"2024-06-10T14:03:13.198964Z","shell.execute_reply.started":"2024-06-10T14:03:12.963313Z","shell.execute_reply":"2024-06-10T14:03:13.197949Z"},"trusted":true},"execution_count":8,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 640x480 with 1 Axes>","image/png":"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"},"metadata":{}}]}]}